<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" 
	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>
<title>Go, uma nova linguagem para os tempos modernos</title>
<!-- metadata -->
<meta name="generator" content="S5" />
<meta name="version" content="S5 1.1" />
<meta name="presdate" content="20110607" />
<meta name="author" content="André Luiz Alves Moraes" />
<meta name="company" content="Rerum Engenharia de Sistemas" />
<meta name="license" content="CC BY-SA 3.0" />
<meta http-equiv="Content-Type" content="text/html; charset=utf8" />
<!-- configuration parameters -->
<meta name="defaultView" content="slideshow" />
<meta name="controlVis" content="hidden" />
<!-- style sheet links -->
<link rel="stylesheet" href="ui/default/slides.css" type="text/css" media="projection" id="slideProj" />
<link rel="stylesheet" href="ui/default/outline.css" type="text/css" media="screen" id="outlineStyle" />
<link rel="stylesheet" href="ui/default/print.css" type="text/css" media="print" id="slidePrint" />
<link rel="stylesheet" href="ui/default/opera.css" type="text/css" media="projection" id="operaFix" />
<!-- S5 JS -->
<script src="ui/default/slides.js" type="text/javascript"></script>
</head>
<body>

<!--
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Brazil License. To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/br/ or send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
-->

<div class="layout">
<div id="controls"><!-- DO NOT EDIT --></div>
<div id="currentSlide"><!-- DO NOT EDIT --></div>
<div id="header"></div>
<div id="footer">
<h1>Sistemas de Informação - UNIPAC - São João Del Rey - 07/06/2011</h1>
<h2>Go, uma nova linguagem para os tempos modernos</h2>
</div>

</div>


<div class="presentation">

<div class="slide">
<h1>Go, uma nova linguagem para os tempos modernos</h1>
<h3>André Luiz Alves Moraes</h3>
<h4>Desenvolvedor @ Rerum Engenharia de Sistemas
<br /><a href="http://andredevchannel.blogspot.com">http://andredevchannel.blogspot.com</a></h4>
<p>Esta palestra está liberada sob CC-BY-SA 3.0
<br />Open/Free/Libre Software!
<br />Padrões abertos fazem o mundo um lugar melhor. Use-os!</p>
</div>

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Por que uma nova linguagem?</h1>
<p>Nos últimos 10 anos não surgiu nenhuma nova linguagem de programação para 
desenvolvimento de sistemas.</p>
<p>Criou-se uma separação entre linguagens compiladas (complicadas) e linguagens
interpretadas (simples). Essa separação porém não é válida.</p>
<p>Ambientes de computação distribuída são passaram a ser o centro do datacenter moderno. 
Porém as linguagens antigas não foram concebidas para este ambiente.</p>
<p>A Google queria uma linguagem melhor para resolver os problemas internos dela.</p>
<div class="handout">
</div>
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Um pouco sobre Go</h1>
<ul>
<li>Criadores:
    <ul>
        <li>Ken Thompson</li>
        <li>Robert Griesemer</li>
        <li>Rob Pike</li>
    </ul>
</li>
<li>Go possui uma sintaxe leve, reduzindo a quantidade de código necessário para desenvolver
os programas.</li>

<li>É uma linguagem compilada e com tipos estáticos, porém o tipo de uma variável pode ser
definido durante a declaração ou definição da mesma</li>
<li>É orientada à objetos porém não possui hierárquia de tipos.</li>
<li>Possui todos os tipos numérios comuns, nas versões com e sem sinal.</li>
</ul>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Um pouco sobre Go (cont.)</h1>
<ul>
<li>Apesar de possuir garbage collector, o usuário possui controle sobre o layout da memória.</li>
<li>Possui versões para os S.O.: linux, bsd, mac os (darwin), windows (port mantido pela comunidade).</li>
<li>Arquiteturas de processador: x86, x86_64(amd64), arm5</li>
<li>Consegue compilar a si mesma (projeto mantido externamente).</li>
</ul>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Vantagens</h1>
<ul>
<li>Compilação é incrivelmente rápida! Aproximadamente 300 mil linhas de código em 30 segundos</li>

<li>Possui tratamento para execução concorrente nativo, sendo assim programas complexos são descritos
de maneira mais sucinta e sem depender de bibliotecas externas.</li>
</ul>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Vantagens</h1>
<ul>
<li>Se bem escritos os programas podem usufruir de execução paralela também.</li>

<li>Possui ponteiros (eles são importantes), porém não possui aritimética de ponteiros (é problemática).</li>

<li>Não efetua conversões automáticamente entre tipos, evitando que detalhes importantes sejam
esquecidos pelo programador.</li>

<li>O código fonte deve estar codificado em UTF-8, sempre!</li>

<li>Tratamento de exceção sem a confusão de try/catch/finally.
<br />Usa defer/panic/recover</li>
</ul>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Uso atual</h1>
<p>Aproximadamente 196 bibliotecas da linguagem e 344 bibliotecas externas</p>
<p>Utilizada internamente em sistemas da Google e recentemente liberada como
plataforma do Google App Engine</p>
<p>Utilizada em sistemas de empresas como Canonical, Atlassian. Outros usuários em:
<a href="http://go-lang.cat-v.org/organizations-using-go">http://go-lang.cat-v.org/organizations-using-go</a></p>
<p>Grupo de discussão conta com aproximadamente 5 mil usuários, incluindo dos principais desenvolvedores da linguagem</p>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Hello World em Go!</h1>
<pre>
package main

import (
	"fmt"
)

func main() {
	fmt.Println("Hello Mr. World")
}
</pre>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Um hello word para a web</h1>
<pre>
package main

import ( "http"; "io"; "log" )

func helloHandler(w http.ResponseWriter, 
  req *http.Request) {
    io.WriteString(w, "Hello Mr. World (from the web)")
}

func main() {
    http.HandleFunc("/hello", helloHandler)
    err := http.ListenAndServe(":8090", nil)
    if err != nil {
        log.Fatal("ListenAndServer: %s", err.String())
    }
}
</pre>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Tipos definidos pelo usuário</h1>
<ul>
<li>O usuário pode definitir structs, interfaces e alias.</li>
<li>As interfaces em GO são conjuntos de métodos, podendo ser este conjunto vazio.
<br />interface{} é o equivalente em GO ao Object do Java ou void* do C++.</li>
<li>O usuário pode definir um tipo que é um alias para um tipo nativo e definir métodos
nesse novo tipo.</li>
</ul>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Concorrência</h1>
<ul>
<li>Apesar de possuir Lock, Mutex, Semaphore a maneira mais idiomática de se trabalhar
concorrência em go é utilizando as "goroutines" associadas aos "channels".</li>

<li>Dessa forma toda a sincronização fica encapsulada no runtime da linguagem, liberando
o programador para focar na solução do problema.</li>

<li>Baseado na linguagem CSP de C. A. R. Hoare (http://www.usingcsp.com/)</li>
</ul>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>goroutines e channels</h1>
<p>Para alcançar um grande grau de concorrência utiliza-se de <strong>goroutines</strong>.
Semelhantes à <em>threads</em> porém consomem menos memória e não sobrecarregam o S.O.</p>
<p>Ao invés de utilizar variáveis globais para comunicarem-se as goroutines utilizam canais de comunicação.</p>
<p>Channels (chan) fornecem um meio seguro de comunicação e sincronização para duas goroutines. Evita problemas comuns de 
leituras incorretas de variáveis</p>
<p>channels e funções são <em>valores de primeira classe</em> sendo assim podem ser passados entre diferentes goroutines</p>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Problema: Load balancer</h1>
<p>Suponha que você está desenvolvendo um sistema onde você possui diversas solicitações
de trabalho para serem processadas e precisa organizar os recursos que você possui
para que cada execute o processamento de modo a reduzir o tempo de espera.
</p>
<strong>Antes de exibir o código vamos ver a aplicação rodando</strong>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->
<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Tipos importantes</h1>
<strong>Apertem os cintos... Ai vêm o código!</strong>
<br/>
<pre>
type Request struct {
	Id       int           
	Pos      int           
	Response chan Response 
}

type Status int

type Worker struct {
	Id      string
	pending int           
	Request chan *Request 
}
</pre>
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide  large-content">
<h1>Worker</h1>
<pre class="large-font-size">
// Funcao principal do trabalhador
func (w *Worker) Start(done chan Worker) {
	for req := range w.Request {
		// simula que esta processando algo
		ret := rand.Int63n(SECOND*int64(req.Id)) % (SECOND * 2)
		time.Sleep(ret)

		// efetua o cast e envia a resposta para o cliente
		req.Response &lt;- Response(ret)
		done &lt;- *w

		if *verbose {
			fmt.Printf("%7v\t%v\t-1\n", req.Pos, w.Id)
		}
	}
}
</pre>
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Load balancer</h1>
<pre>
type Balancer struct {
	wp        WorkerPool 
	load      map[string]int
	requests  chan *Request 
	done      chan Worker   
	reqC      int           
	algorithm sorter        
	exit      chan int      
}
</pre>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide large-content">
<h1>Load Balancer - Rotina principal</h1>
<pre class="large-font-size">
func (b *Balancer) DistributeLoad() {
	t := time.NewTicker(SECOND / 2)
	for {
		select {
		case req := &lt;-b.requests:
			b.dispatch(req)
		case w := &lt;-b.done:
			b.receive(w)
		case &lt;-t.C:
			fmt.Fprintf(os.Stdout, "%v\n", b)
		}
	}
}
</pre>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Clientes</h1>
<pre class="large-font-size">
func producer(req chan *Request) {
	i := int(0)
	for {
		i++
		time.Sleep(SECOND + rand.Int63n(SECOND))
		ret := make(chan Response)
		r := &Request{i, -1, ret}
		req &lt;- r
		&lt;-ret
	}
}

func producers(req chan *Request, pCount int) {
	t := time.NewTicker(SECOND / 100)
	for i := 0; i &lt; pCount; i++ {
		go producer(req)
		&lt;-t.C
	}
}
</pre>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Rotina inicial</h1>
<pre class="large-font-size">
var (
	poolSize = flag.Int("w", 10, "Number of workers")
	factor   = flag.Int("f", 50, "Number of clients por worker")
	nclients = flag.Int("n", 500, "Number of clients")
	rrobin   = flag.Bool("rr", false, "Usa Round-Robin ao invés de balanceamento")
	verbose  = flag.Bool("v", false, "Verbose")
)

func main() {
	flag.Parse()
	bl := NewBalancer(*poolSize, *factor)
	go bl.DistributeLoad()
	go producers(bl.requests, *nclients)
	&lt;-bl.exit
}
</pre>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Onde conseguir mais informações?</h1>
<ul>
<li>Site oficial: <a href="http://golang.org" title="Go lang">http://golang.org</a></li>
<li>Grupo de discussão: <a href="http://groups.google.com/group/golang-nuts" title="Go lang nuts">http://groups.google.com/group/golang-nuts</a></li>
<li>Lista de pacotes pública: <a href="http://godashboard.appspot.com/project" title="Project dashboard">http://godashboard.appspot.com/project</a></li>
<li>Blog oficial: <a href="http://blog.golang.org/" title="Blog oficial">http://blog.golang.org/</a></li>
<li>Repositório oficial: <a href="http://code.google.com/p/go/" title="Go lang official repository">http://code.google.com/p/go/</a></li>
<li>Meu blog: <a href="http://andredevchannel.blogspot.com" title="Andre Dev Channel">http://andredevchannel.blogspot.com</a></li>
<li>Go-Lang @ cat-v: <a href="http://go-lang.cat-v.org">http://go-lang.cat-v.org</a></li>
</ul>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

<!----------------------- ----------------------------------- BEGIN OF SLIDE -->
<div class="slide">
<h1>Agora a parte mais interessante!</h1>
<h2>Perguntas???</h2>
</div>
<div class="handout">
</div>
<!----------------------- ------------------------------------- END OF SLIDE -->

</div>

</body>
</html>
